{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default_exp vision.core\n",
    "#default_cls_lvl 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from fastai.torch_basics import *\n",
    "from fastai.data.all import *\n",
    "\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastai.data.external import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "from nbdev.showdoc import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "_all_ = ['Image','ToTensor']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#It didn't use to be necessary to add ToTensor in all but we don't have the encodes methods defined here otherwise.\n",
    "#TODO: investigate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Core vision\n",
    "> Basic image opening/processing functionality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "imagenet_stats = ([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "cifar_stats    = ([0.491, 0.482, 0.447], [0.247, 0.243, 0.261])\n",
    "mnist_stats    = ([0.131], [0.308])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = Image.open(TEST_IMAGE).resize((30,20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "if not hasattr(Image,'_patched'):\n",
    "    _old_sz = Image.Image.size.fget\n",
    "    @patch_property\n",
    "    def size(x:Image.Image): return fastuple(_old_sz(x))\n",
    "    Image._patched = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch_property\n",
    "def n_px(x: Image.Image): return x.size[0] * x.size[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Image.n_px`\n",
    "\n",
    "> `Image.n_px` (property)\n",
    "\n",
    "Number of pixels in image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.n_px, 30*20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch_property\n",
    "def shape(x: Image.Image): return x.size[1],x.size[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Image.shape`\n",
    "\n",
    "> `Image.shape` (property)\n",
    "\n",
    "Image (height,width) tuple (NB: opposite order of `Image.size()`, same order as numpy array and pytorch tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.shape, (20,30))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch_property\n",
    "def aspect(x: Image.Image): return x.size[0]/x.size[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Image.aspect`\n",
    "\n",
    "> `Image.aspect` (property)\n",
    "\n",
    "Aspect ratio of the image, i.e. `width/height`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.aspect, 30/20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def reshape(x: Image.Image, h, w, resample=0):\n",
    "    \"`resize` `x` to `(w,h)`\"\n",
    "    return x.resize((w,h), resample=resample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.reshape\" class=\"doc_header\"><code>Image.reshape</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.reshape</code>(**`x`**:`Image`, **`h`**, **`w`**, **`resample`**=*`0`*)\n",
       "\n",
       "`resize` `x` to `(w,h)`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.reshape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.reshape(12,10).shape, (12,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def to_bytes_format(im:Image.Image, format='png'):\n",
    "    \"Convert to bytes, default to PNG format\"\n",
    "    arr = io.BytesIO()\n",
    "    im.save(arr, format=format)\n",
    "    return arr.getvalue()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.to_bytes_format\" class=\"doc_header\"><code>Image.to_bytes_format</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.to_bytes_format</code>(**`im`**:`Image`, **`format`**=*`'png'`*)\n",
       "\n",
       "Convert to bytes, default to PNG format"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.to_bytes_format)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def to_thumb(self:Image.Image, h, w=None):\n",
    "    \"Same as `thumbnail`, but uses a copy\"\n",
    "    if w is None: w=h\n",
    "    im = self.copy()\n",
    "    im.thumbnail((w,h))\n",
    "    return im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.to_thumb\" class=\"doc_header\"><code>Image.to_thumb</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.to_thumb</code>(**`h`**, **`w`**=*`None`*)\n",
       "\n",
       "Same as `thumbnail`, but uses a copy"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.to_thumb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def resize_max(x: Image.Image, resample=0, max_px=None, max_h=None, max_w=None):\n",
    "    \"`resize` `x` to `max_px`, or `max_h`, or `max_w`\"\n",
    "    h,w = x.shape\n",
    "    if max_px and x.n_px>max_px: h,w = fastuple(h,w).mul(math.sqrt(max_px/x.n_px))\n",
    "    if max_h and h>max_h: h,w = (max_h    ,max_h*w/h)\n",
    "    if max_w and w>max_w: h,w = (max_w*h/w,max_w    )\n",
    "    return x.reshape(round(h), round(w), resample=resample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(im.resize_max(max_px=20*30).shape, (20,30))\n",
    "test_eq(im.resize_max(max_px=300).n_px, 294)\n",
    "test_eq(im.resize_max(max_px=500, max_h=10, max_w=20).shape, (10,15))\n",
    "test_eq(im.resize_max(max_h=14, max_w=15).shape, (10,15))\n",
    "test_eq(im.resize_max(max_px=300, max_h=10, max_w=25).shape, (10,15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"Image.resize_max\" class=\"doc_header\"><code>Image.resize_max</code><a href=\"__main__.py#L2\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>Image.resize_max</code>(**`x`**:`Image`, **`resample`**=*`0`*, **`max_px`**=*`None`*, **`max_h`**=*`None`*, **`max_w`**=*`None`*)\n",
       "\n",
       "`resize` `x` to `max_px`, or `max_h`, or `max_w`"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(Image.Image.resize_max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section regroups the basic types used in vision with the transform that create objects of those types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def to_image(x):\n",
    "    \"Convert a tensor or array to a PIL int8 Image\"\n",
    "    if isinstance(x,Image.Image): return x\n",
    "    if isinstance(x,Tensor): x = to_np(x.permute((1,2,0)))\n",
    "    if x.dtype==np.float32: x = (x*255).astype(np.uint8)\n",
    "    return Image.fromarray(x, mode=['RGB','CMYK'][x.shape[0]==4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def load_image(fn, mode=None):\n",
    "    \"Open and load a `PIL.Image` and convert to `mode`\"\n",
    "    im = Image.open(fn)\n",
    "    im.load()\n",
    "    im = im._new(im.im)\n",
    "    return im.convert(mode) if mode else im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def image2tensor(img):\n",
    "    \"Transform image to byte tensor in `c*h*w` dim order.\"\n",
    "    res = tensor(img)\n",
    "    if res.dim()==2: res = res.unsqueeze(-1)\n",
    "    return res.permute(2,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILBase(Image.Image, metaclass=BypassNewMeta):\n",
    "    _bypass_type=Image.Image\n",
    "    _show_args = {'cmap':'viridis'}\n",
    "    _open_args = {'mode': 'RGB'}\n",
    "    @classmethod\n",
    "    def create(cls, fn:(Path,str,Tensor,ndarray,bytes), **kwargs)->None:\n",
    "        \"Open an `Image` from path `fn`\"\n",
    "        if isinstance(fn,TensorImage): fn = fn.permute(1,2,0).type(torch.uint8)\n",
    "        if isinstance(fn, TensorMask): fn = fn.type(torch.uint8)\n",
    "        if isinstance(fn,Tensor): fn = fn.numpy()\n",
    "        if isinstance(fn,ndarray): return cls(Image.fromarray(fn))\n",
    "        if isinstance(fn,bytes): fn = io.BytesIO(fn)\n",
    "        return cls(load_image(fn, **merge(cls._open_args, kwargs)))\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        \"Show image using `merge(self._show_args, kwargs)`\"\n",
    "        return show_image(self, ctx=ctx, **merge(self._show_args, kwargs))\n",
    "\n",
    "    def __repr__(self): return f'{self.__class__.__name__} mode={self.mode} size={\"x\".join([str(d) for d in self.size])}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILImage(PILBase): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILImageBW(PILImage): _show_args,_open_args = {'cmap':'Greys'},{'mode': 'L'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = PILImage.create(TEST_IMAGE)\n",
    "test_eq(type(im), PILImage)\n",
    "test_eq(im.mode, 'RGB')\n",
    "test_eq(str(im), 'PILImage mode=RGB size=1200x803')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64 at 0x7FB0E5BEF550>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im.resize((64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = im.show(figsize=(1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_fig_exists(ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timg = TensorImage(image2tensor(im))\n",
    "tpil = PILImage.create(timg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=64x64 at 0x7FB0E5C0C750>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tpil.resize((64,64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "test_eq(np.array(im), np.array(tpil))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PILMask(PILBase): _open_args,_show_args = {'mode':'L'},{'alpha':0.5, 'cmap':'tab20'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = PILMask.create(TEST_IMAGE)\n",
    "test_eq(type(im), PILMask)\n",
    "test_eq(im.mode, 'L')\n",
    "test_eq(str(im), 'PILMask mode=L size=1200x803')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "OpenMask = Transform(PILMask.create)\n",
    "OpenMask.loss_func = CrossEntropyLossFlat(axis=1)\n",
    "PILMask.create = OpenMask"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mnist = untar_data(URLs.MNIST_TINY)\n",
    "fns = get_image_files(mnist)\n",
    "mnist_fn = TEST_IMAGE_BW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA4klEQVR4nGNgGEjgu/Xf//gIrFLMiZ/+/v3793cpPxZJkWN/IeC9NUKQCUq/Wfab4fv9VwwMfP7YDM5r3MAQ/Pfv30MSWO2VYgj++/fvXwMMYxkYGBieMTAwMDAceIZVEgLOvsIhmYLVOgYGBgYGx29///5dz4Jdcs3fv3//uuHQ6fT379+/78ywSwo6vvj79+9UVhx6dXv//v1bjUVC8+zZs4pMDX//fk2GCSHcxmnAwLBlnQEDw6cbmDqNoNHy9wpcCBEIj/fhcAjEXKvNv//+/XtbB4d899+/TYb4DKA9AABLQV4KAJgjfgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "PILImageBW mode=L size=28x28"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timg = Transform(PILImageBW.create)\n",
    "mnist_img = timg(mnist_fn)\n",
    "test_eq(mnist_img.size, (28,28))\n",
    "assert isinstance(mnist_img, PILImageBW)\n",
    "mnist_img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Segmentation masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class AddMaskCodes(Transform):\n",
    "    \"Add the code metadata to a `TensorMask`\"\n",
    "    def __init__(self, codes=None):\n",
    "        self.codes = codes\n",
    "        if codes is not None: self.vocab,self.c = codes,len(codes)\n",
    "\n",
    "    def decodes(self, o:TensorMask):\n",
    "        if self.codes is not None: o._meta = {'codes': self.codes}\n",
    "        return o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "camvid = untar_data(URLs.CAMVID_TINY)\n",
    "fns = get_image_files(camvid/'images')\n",
    "cam_fn = fns[0]\n",
    "mask_fn = camvid/'labels'/f'{cam_fn.stem}_P{cam_fn.suffix}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cam_img = PILImage.create(cam_fn)\n",
    "test_eq(cam_img.size, (128,96))\n",
    "tmask = Transform(PILMask.create)\n",
    "mask = tmask(mask_fn)\n",
    "test_eq(type(mask), PILMask)\n",
    "test_eq(mask.size, (128,96))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_,axs = plt.subplots(1,3, figsize=(12,3))\n",
    "cam_img.show(ctx=axs[0], title='image')\n",
    "mask.show(alpha=1, ctx=axs[1], vmin=1, vmax=30, title='mask')\n",
    "cam_img.show(ctx=axs[2], title='superimposed')\n",
    "mask.show(ctx=axs[2], vmin=1, vmax=30);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class TensorPoint(TensorBase):\n",
    "    \"Basic type for points in an image\"\n",
    "    _show_args = dict(s=10, marker='.', c='r')\n",
    "\n",
    "    @classmethod\n",
    "    def create(cls, t, img_size=None)->None:\n",
    "        \"Convert an array or a list of points `t` to a `Tensor`\"\n",
    "        return cls(tensor(t).view(-1, 2).float(), img_size=img_size)\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        if 'figsize' in kwargs: del kwargs['figsize']\n",
    "        x = self.view(-1,2)\n",
    "        ctx.scatter(x[:, 0], x[:, 1], **{**self._show_args, **kwargs})\n",
    "        return ctx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "TensorPointCreate = Transform(TensorPoint.create)\n",
    "TensorPointCreate.loss_func = MSELossFlat()\n",
    "TensorPoint.create = TensorPointCreate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Points are expected to come as an array/tensor of shape `(n,2)` or as a list of lists with two elements. Unless you change the defaults in `PointScaler` (see later on), coordinates should go from 0 to width/height, with the first one being the column index (so from 0 to width) and the second one being the row index (so from 0 to height).\n",
    "\n",
    "> Note: This is different from the usual indexing convention for arrays in numpy or in PyTorch, but it's the way points are expected by matplotlib or the internal functions in PyTorch like `F.grid_sample`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pnt_img = TensorImage(mnist_img.resize((28,35)))\n",
    "pnts = np.array([[0,0], [0,35], [28,0], [28,35], [9, 17]])\n",
    "tfm = Transform(TensorPoint.create)\n",
    "tpnts = tfm(pnts)\n",
    "test_eq(tpnts.shape, [5,2])\n",
    "test_eq(tpnts.dtype, torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ctx = pnt_img.show(figsize=(1,1), cmap='Greys')\n",
    "tpnts.show(ctx=ctx);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bounding boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def get_annotations(fname, prefix=None):\n",
    "    \"Open a COCO style json in `fname` and returns the lists of filenames (with maybe `prefix`) and labelled bboxes.\"\n",
    "    annot_dict = json.load(open(fname))\n",
    "    id2images, id2bboxes, id2cats = {}, collections.defaultdict(list), collections.defaultdict(list)\n",
    "    classes = {o['id']:o['name'] for o in annot_dict['categories']}\n",
    "    for o in annot_dict['annotations']:\n",
    "        bb = o['bbox']\n",
    "        id2bboxes[o['image_id']].append([bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]])\n",
    "        id2cats[o['image_id']].append(classes[o['category_id']])\n",
    "    id2images = {o['id']:ifnone(prefix, '') + o['file_name'] for o in annot_dict['images'] if o['id'] in id2bboxes}\n",
    "    ids = list(id2images.keys())\n",
    "    return [id2images[k] for k in ids], [(id2bboxes[k], id2cats[k]) for k in ids]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#TODO explain and/or simplify this\n",
    "coco = untar_data(URLs.COCO_TINY)\n",
    "images, lbl_bbox = get_annotations(coco/'train.json')\n",
    "annots = json.load(open(coco/'train.json'))\n",
    "test_eq(images, [k['file_name'] for k in annots['images']])\n",
    "for _ in range(5):\n",
    "    idx = random.randint(0, len(images)-1)\n",
    "    fn = images[idx]\n",
    "    i = 0\n",
    "    while annots['images'][i]['file_name'] != fn: i+=1\n",
    "    img_id = annots['images'][i]['id']\n",
    "    bbs = [ann for ann in annots['annotations'] if ann['image_id'] == img_id]\n",
    "    i2o = {k['id']:k['name'] for k in annots['categories']}\n",
    "    lbls = [i2o[bb['category_id']] for bb in bbs]\n",
    "    bboxes = [bb['bbox'] for bb in bbs]\n",
    "    bboxes = [[bb[0],bb[1], bb[0]+bb[2], bb[1]+bb[3]] for bb in bboxes]\n",
    "    test_eq(lbl_bbox[idx], [bboxes, lbls])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "from matplotlib import patches, patheffects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "def _draw_outline(o, lw):\n",
    "    o.set_path_effects([patheffects.Stroke(linewidth=lw, foreground='black'), patheffects.Normal()])\n",
    "\n",
    "def _draw_rect(ax, b, color='white', text=None, text_size=14, hw=True, rev=False):\n",
    "    lx,ly,w,h = b\n",
    "    if rev: lx,ly,w,h = ly,lx,h,w\n",
    "    if not hw: w,h = w-lx,h-ly\n",
    "    patch = ax.add_patch(patches.Rectangle((lx,ly), w, h, fill=False, edgecolor=color, lw=2))\n",
    "    _draw_outline(patch, 4)\n",
    "    if text is not None:\n",
    "        patch = ax.text(lx,ly, text, verticalalignment='top', color=color, fontsize=text_size, weight='bold')\n",
    "        _draw_outline(patch,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class TensorBBox(TensorPoint):\n",
    "    \"Basic type for a tensor of bounding boxes in an image\"\n",
    "    @classmethod\n",
    "    def create(cls, x, img_size=None)->None: return cls(tensor(x).view(-1, 4).float(), img_size=img_size)\n",
    "\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        x = self.view(-1,4)\n",
    "        for b in x: _draw_rect(ctx, b, hw=False, **kwargs)\n",
    "        return ctx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bounding boxes are expected to come as tuple with an array/tensor of shape `(n,4)` or as a list of lists with four elements and a list of corresponding labels. Unless you change the defaults in `PointScaler` (see later on), coordinates for each bounding box should go from 0 to width/height, with the following convention: x1, y1, x2, y2 where (x1,y1) is your top-left corner and (x2,y2) is your bottom-right corner.\n",
    "\n",
    "> Note: We use the same convention as for points with x going from 0 to width and y going from 0 to height."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "class LabeledBBox(L):\n",
    "    \"Basic type for a list of bounding boxes in an image\"\n",
    "    def show(self, ctx=None, **kwargs):\n",
    "        for b,l in zip(self.bbox, self.lbl):\n",
    "            if l != '#na#': ctx = retain_type(b, self.bbox).show(ctx=ctx, text=l)\n",
    "        return ctx\n",
    "\n",
    "    bbox,lbl = add_props(lambda i,self: self[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = untar_data(URLs.COCO_TINY)\n",
    "images, lbl_bbox = get_annotations(coco/'train.json')\n",
    "idx=2\n",
    "coco_fn,bbox = coco/'train'/images[idx],lbl_bbox[idx]\n",
    "coco_img = timg(coco_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tbbox = LabeledBBox(TensorBBox(bbox[0]), bbox[1])\n",
    "ctx = coco_img.show(figsize=(3,3), cmap='Greys')\n",
    "tbbox.show(ctx=ctx);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unless specifically mentioned, all the following transforms can be used as single-item transforms (in one of the list in the `tfms` you pass to a `TfmdDS` or a `Datasource`) or tuple transforms (in the `tuple_tfms` you pass to a `TfmdDS` or a `Datasource`). The safest way that will work across applications is to always use them as `tuple_tfms`. For instance, if you have points or bounding boxes as targets and use `Resize` as a single-item transform, when you get to `PointScaler` (which is a tuple transform) you won't have the correct size of the image to properly scale your points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "PILImage  ._tensor_cls = TensorImage\n",
    "PILImageBW._tensor_cls = TensorImageBW\n",
    "PILMask   ._tensor_cls = TensorMask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@ToTensor\n",
    "def encodes(self, o:PILBase): return o._tensor_cls(image2tensor(o))\n",
    "@ToTensor\n",
    "def encodes(self, o:PILMask): return o._tensor_cls(image2tensor(o)[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any data augmentation transform that runs on PIL Images must be run before this transform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ToTensor:\n",
      "(PILMask,object) -> encodes\n",
      "(PILBase,object) -> encodes\n",
      " \n",
      "<class '__main__.PILImageBW'>\n",
      "<class 'fastai.torch_core.TensorImageBW'>\n"
     ]
    }
   ],
   "source": [
    "tfm = ToTensor()\n",
    "print(tfm)\n",
    "print(type(mnist_img))\n",
    "print(type(tfm(mnist_img)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfm = ToTensor()\n",
    "test_eq(tfm(mnist_img).shape, (1,28,28))\n",
    "test_eq(type(tfm(mnist_img)), TensorImageBW)\n",
    "test_eq(tfm(mask).shape, (96,128))\n",
    "test_eq(type(tfm(mask)), TensorMask)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's confirm we can pipeline this with `PILImage.create`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 72x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pipe_img = Pipeline([PILImageBW.create, ToTensor()])\n",
    "img = pipe_img(mnist_fn)\n",
    "test_eq(type(img), TensorImageBW)\n",
    "pipe_img.show(img, figsize=(1,1));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def _cam_lbl(x): return mask_fn\n",
    "cam_tds = Datasets([cam_fn], [[PILImage.create, ToTensor()], [_cam_lbl, PILMask.create, ToTensor()]])\n",
    "show_at(cam_tds, 0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n",
    "\n",
    "> Warning: This transform needs to run on the tuple level, before any transform that changes the image size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def _scale_pnts(y, sz, do_scale=True, y_first=False):\n",
    "    if y_first: y = y.flip(1)\n",
    "    res = y * 2/tensor(sz).float() - 1 if do_scale else y\n",
    "    return TensorPoint(res, img_size=sz)\n",
    "\n",
    "def _unscale_pnts(y, sz): return TensorPoint((y+1) * tensor(sz).float()/2, img_size=sz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class PointScaler(Transform):\n",
    "    \"Scale a tensor representing points\"\n",
    "    order = 1\n",
    "    def __init__(self, do_scale=True, y_first=False): self.do_scale,self.y_first = do_scale,y_first\n",
    "    def _grab_sz(self, x):\n",
    "        self.sz = [x.shape[-1], x.shape[-2]] if isinstance(x, Tensor) else x.size\n",
    "        return x\n",
    "\n",
    "    def _get_sz(self, x):\n",
    "        sz = x.get_meta('img_size')\n",
    "        assert sz is not None or self.sz is not None, \"Size could not be inferred, pass it in the init of your TensorPoint with `img_size=...`\"\n",
    "        return self.sz if sz is None else sz\n",
    "\n",
    "    def setups(self, dl):\n",
    "        its = dl.do_item(0)\n",
    "        for t in its:\n",
    "            if isinstance(t, TensorPoint): self.c = t.numel()\n",
    "\n",
    "    def encodes(self, x:(PILBase,TensorImageBase)): return self._grab_sz(x)\n",
    "    def decodes(self, x:(PILBase,TensorImageBase)): return self._grab_sz(x)\n",
    "\n",
    "    def encodes(self, x:TensorPoint): return _scale_pnts(x, self._get_sz(x), self.do_scale, self.y_first)\n",
    "    def decodes(self, x:TensorPoint): return _unscale_pnts(x.view(-1, 2), self._get_sz(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To work with data augmentation, and in particular the `grid_sample` method, points need to be represented with coordinates going from -1 to 1 (-1 being top or left, 1 bottom or right), which will be done unless you pass `do_scale=False`. We also need to make sure they are following our convention of points being x,y coordinates, so pass along `y_first=True` if you have your data in an y,x format to add a flip.\n",
    "\n",
    "> Note: This transform automatically grabs the sizes of the images it sees before a <code>TensorPoint</code> object and embeds it in them. For this to work, those images need to be before any points in the order of your final tuple. If you don't have such images, you need to embed the size of the corresponding image when creating a <code>TensorPoint</code> by passing it with `sz=...`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _pnt_lbl(x): return TensorPoint.create(pnts)\n",
    "def _pnt_open(fn): return PILImage(PILImage.create(fn).resize((28,35)))\n",
    "pnt_tds = Datasets([mnist_fn], [_pnt_open, [_pnt_lbl]])\n",
    "pnt_tdl = TfmdDL(pnt_tds, bs=1, after_item=[PointScaler(), ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_eq(pnt_tdl.after_item.c, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#Check the size was grabbed by PointScaler and added to y\n",
    "tfm = PointScaler()\n",
    "tfm.as_item=False\n",
    "x,y = tfm(pnt_tds[0])\n",
    "test_eq(tfm.sz, x.size)\n",
    "test_eq(y.get_meta('img_size'), x.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y = pnt_tdl.one_batch()\n",
    "#Scaling and flipping properly done\n",
    "#NB: we added a point earlier at (9,17); formula below scales to (-1,1) coords\n",
    "test_close(y[0], tensor([[-1., -1.], [-1.,  1.], [1.,  -1.], [1., 1.], [9/14-1, 17/17.5-1]]))\n",
    "a,b = pnt_tdl.decode_batch((x,y))[0]\n",
    "test_eq(b, tensor(pnts).float())\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorPoint)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), TensorPoint)\n",
    "test_eq(b.get_meta('img_size'), (28,35)) #Automatically picked the size of the input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGUAAAB7CAYAAABtoE4kAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAQdElEQVR4nO1dS3eb1tp+AAESIIGELr7UtZvUTdJk9ctqM+qko86an3RG31/6Jp1m1kFXc9bqLXbslTR2ZMsCCSQQIC7foNnbSJYcu82xtnt41mLhKMgW++Hd7/0Vl2UZCrAFftUfoMBFFKQwiIIUBlGQwiAKUhhEQQqDKF32nxzHFfbyB0CWZdx1rn+vpHwH4Kd35wJ/ERz3FBz3HBz39ErXZ1m29ACQ/QRk2bsziuMvHRnwPCPnS9abrvv7SPnuHSHfMXBzt/XIgKfviHl6FVK4y8IshU75MPjgOqXAzaMghUEUpDCIghQGUZDCIC716G8SHPengcLzPP03eS2PLMuQpikWWY3/lIQdE6RwHAee58FxHARBoD+Tcx5pmmI6nSJN05nXsyxDkiQ3+bH/Y2CCFJ7nZ0ghxJBzHkmSIMsyxHE883qapuA47h8hLSsnhed5VKtVqKoKSZLQbrdhGAZEUYRhGFAUhV7LcRwcx8HBwQFs257xgieTCQaDAaIoWuHdfBisnJRSqYR6vY52u41arYZHjx5hZ2cHmqZhe3sbrVaLbmEcx+GPP/7A999/j/39faRpSiWn3+/D9/2ClL8DstCCIKBcLkPTNFSrVTQaDbTbbVSrVWxsbKDT6cwo/el0ikajgWq1SrexNE3h+z5EUQTP8/nY3a3ESkjJb1mqquLBgwfY3d1FtVrF7u4uNjc3UalUUKvVIMvyjLI3DAP37t2DoihUuWdZhjdv3iCOY5ydncH3fQwGA0yn01Xc3t/GSkgRBAGGYWBtbQ2GYeCrr77Cl19+iUqlgna7jXq9jlKpBFVVIcvyzHtN08Tjx49x586dGfN4f38fk8kEx8fH6PV68H2/IOWqIKauLMtQVRWapqFWq8EwDFQqFWiahnK5DEEQUCqVLpjEoihCVVVqaZFD13XUajW4rgvP8yBJEkRRRJqmS/0aVnGjpBBzV5ZldDod7O7uwjAMbG1todPpQJIkKIoCWZYX+ijAn4aBpmmQZXlGd2xubuLBgwcwTRNra2uoVqtwXRfD4RC9Xg9hGGI6nWI6nTJP0I2TIooiKpUKNjY28Pnnn8MwDHzyySdYX1+fcRyXoVQqoVarLVzYKIrgOA7Ozs7QbrcxGo3w6tUrxHEM13UxmUwQx3FByjzI9iVJEiqVCiqVCt1qBEGg15GFy7LsAknzDiUASJIEVVWRZRmiKEK9XocoirBtG7IsQxRFTKfTSwlnBTdKCjFtCSmqqkJRFIiieOn73vdkcxwHWZbRarWg6zoMw4BpmgjDEOVyGScnJyiXy+j3+/A8j/lwzI2RkncAeZ6nvomqqhBFcWnwkZzniZm/vlwuo9Pp0GuTJKEKfm9vD6VSCXEco9fr/Yfu8MPhxkjJLypZtDiOqfNHAoz5xc6TQq7JO5KE4PmfgT+ttCzLUKlUUC6XUS6Xl5LPGm50+yJBRN/30e12sbe3B8MwoOs6ms0mSqUSVfR5HySOY0wmE0RRBJ7nUSqVqMlMFhs4J5EsPCFlbW0NPM/DcRyUSiuPLL0XN/oJkyRBkiTgeR4nJyfY29uDaZrY3t5GGIZIkoQSk9+CoijCcDiE7/s0LJMnZF4n5aVSURR0Oh2USiW8ffu2IGUZ0jRFGIYYj8eQZRme58HzPIiiSKUgv3UFQQDXdeG6LvX0JUlCmqbQNO3Sv0UcVWKBkTQBy/GxlZCSJAl6vR7SNIWu6zBNExzHQRRFuniCINAwS7/fxw8//IDDw0Ooqor19XUasHzy5AlUVV36t2RZhmEY4DiOpgImkwnTjuRKSCGBw+FwSCPDHMdR34U82c1mE7qu4/Xr13j27Bl+/PFHGpBsNpu4d+8e7t+/f+nfkiQJuq6D53nUajUoigLP8wCA2djYyjbYNE0RxzGiKILneXAcB5IkIQzDme0GAI1n+b4PWZYRBAHCMEQURRfSwvMg29d0OoUkSXR7zBsUrGGlpBB9cXR0hDiOIQgCXThJkmCaJqrVKvr9Pk5PTxFFEcIwpMeiXP08FEWhCbRmswlN06gD6fv+Dd3t9bAyUoiijaII3W4XruvOFE5IkoR6vQ5N0zAej2HbNqIoorpgOp1eKY5VLpdhmiam0ynq9TpUVUW5XMZkMmHWZ1m5fUhM3yiKqAPI8zzNJnIcRwOJ/y1gghTiowDn8TFBEBAEAQ0kTiYT+p58pcv7nnZCONFB+QgCi/oEYIQUsh3lwXEcPM+bcSTJ6/nA5vtAnM88ISSFzCpWTsoyEJ0z/0Qv+3kZkiRBGIbUYovjmEYKWAWzpADnBXbARTKu6pH7vo+TkxOMx2P0ej1qXodhyKy0ME0KsFgaFrQBLkUYhhgMBnAcB47jwPd95jOQt7LqPq9TrqLop9MpNafJ1lVsXx8QxDIjnvllpBA/yHEcDAYDjEYjqlsK6+sDgkjIouLvRSC5GM/zaE6GdZ/n1m1fgiBA0zQYhgFN0y7Nj+TN52X9Lizi1kmKoijY3t7G/fv3sbGxMVOVn0e+Cek6ziYLuHWSIooiTNPExsYGms3mhbLWeeRDN7eBEIBhSeE4jipzkhOpVCrY2dlBq9WiuZF8rRhwXmRBLC1SnNfv9+G6LvPlRQDDpAiCgGq1CkVRYJomnjx5gu3tbTSbTXzxxRdYW1ujVSrzmEwmsG0bQRDg5cuXeP78OU5OTtDtdm9F/wqzpJDaMFVVYZom7t27h4cPH9I0sK7rKJVKCxV9HMcYj8fwfR/9fh/Hx8fodrtwHId5ywtgmBRBEGhiqtVqodFooNFo0DouUgSxSE8EQQDbtuE4Dmzbxng8pnl5Vn2TPJglRZZlbG1t4dNPP8X6+jru37+P3d1dWrVP2iQWkeI4Dn7//Xecnp5ib28PJycnsG2b+UAkATPW1/ywt1KpBF3X0el00G630Ww20Wg0YBgGrfta5tEHQYB+v49utwvLsqikRFF0KySFGVL+F8Djd2cAtORIkiRIkkS996suav662+SjAAyR8i8Az9+dgXNFTyywRQp9GUH5CDIpcyUFGbeBGGZ0yv+9OwiIn0KqJucX8zrbUD7vfxvADCnziOMYlmXh+PgYSZLA8zzEcXylOFa1WsWdO3doW/fR0RE4joPv+7SemWUwS0oQBHj9+jWm0yl2dnbw8OFDbG9vg+d5ag4DF/tUAKDT6eDrr79GEASo1Wo4OjqCLMuwLAuTyaQg5a8iSRKMRiNYlgVd1xEEAS3YI1ZXvk8lv52R9ockSXBwcEC7hsfjcaFT/g7SNEUQBBiPx7AsCy9evIAoiqhWq/j4449p0fYis5gEIbMsg6IoaLVatExpPlbGIpglhUgK6fZ69uwZ9vf3sbW1hW+//ZYGI8ki56Ulnyom3ceapiEIAuzv76/ytq4EZkkhHVykj+X09BRxHEOSJKqwOY5DmqZUKoDZ3so0TSFJEqrVKqIoQqVSuVK2ctVgmhQSq+I4Dv1+H5PJBDzP4+eff0YYhlAUBc1mk7ZPVKvVma4ujuOgqio2Njagqip6vR62tragqirG4zFc12XSTGaWFFLZOJ1OEQQBPM+DIAgYDAaQZRn7+/s0ekyClTs7O5AkCcC5H2MYBj777DMEQUBnt/T7fRwdHTE7ioo5Uua7g8niEjN2NBrh7OwMgiAgTVPaz1gulxeWo4qiCE3TaKJM13VMp1NYlsWs0meClHy3r67rF9rl8v2PpEeSPOmCIKBer2Nzc5O2zsmyTIsq8o2rrVYLd+/eRaPRoM7peDymUsRKsHLlpJC2OjIs586dO1hfX5+ZUgScS814PMabN2/gOA5UVUW/34eqqrh79y4URcFoNEKj0aCxLhKmybIMH330ER4/fozRaIQsy2iLn2VZM5X/qwYTpJCgIdlqDMOY6eDNH6S6kbRGOI5DC+7G4zE8z4OqqjN1yOR3lctl1Go1WqbE6tADJkghk40Mw8Ddu3fx6NGjC6F6Qsrp6SltJuI4jrZRDIdD9Pt9SJIEWZYXPvWVSgXNZhOqqqLVatGu5NFoVJCSB8dxdE6LaZp49OgRvvnmm6X+xKtXr2DbNgBQ/4Xk4rvdLtI0RaVSmel3IcQqigJJkhBFEdbX19FutyEIAmzbZsp/WTkpwHlnFpl6p+v6UsvIMAxUq1VomoY0Tel1xNkk/SfzSpvkVogfkx+kwBIhAAOkzFcykl76ZeWopMTINE0MBgO02204joN2u42trS3U63UYhrHw/aTVLooijEYjDAYDDAYD+L7PjOUFMEAKMFtaSmZLLpOUTqeDJ0+e4MGDB7AsCxsbG7BtG7VaDWtra1BVlQ5gmwcp9iZjRSzLgmVZ8DyPKc+eCVII8iWmy7YUYqGR+V2GYdAZLYqioFwuQ5KkS7+8gPSskOZUVkxhAmZIuar1Q3L3JEVMspLEYSSkLZKUfKcwydWQaXmFpCzBVfLwPM+jUqnQXImu69QnIbkVYjTMI9+U6rouzs7OcHZ2xlw9GDOk5B3DvOO3SILI1pafrzKfiXyf5JHZMKSNmyWsnBTSAjeZTOD7PlzXxWAwoFbYMv0AXCTsMiLybXn5QW+sEQIwQgpJ1fq+j9FohOFwSM3i+f4TIgVka1tmOue3vrzZTSbpsTyIbeWkAKAWETFZx+MxkiSZiUstKpa4DvIzYMiQAxYJARgghTT4TCYTDIdD7O3tQVEUmjGs1+uQZRmmaVL/hRR4EyxaXEJaXk/Zto29vT24rkvTyyxi5aQAoMPUXNfFy5cvkSQJNE2DZVlot9s0pJJlGQ3JE1KuOgokSRLYto3Dw0PYtl2QchnyIfk4juH7Pm3u0XUdoigijmOMRiNUKpWZbY1gkSlNyCKDDfK/23EcBEHApJIHGCAFOJ+S5/s+jo6O4DgOHYdOxqQ7jkM7uEj2kKSB55V9HMe0eM/zPAyHQ4RhiN9++w0//fQTLMvC0dFRMUPyMpAnNkkSdLtdnJycQBRFdLtdKIqCRqOBLMvgui5arRYMw4AsyzRjOQ8iFVEUYTAYoNvtwvd9HBwc4JdffoFlWfB9v9i+ror8ePUwDMHzPCaTCW2VK5VKcF2XtkgsapOYTqcYj8cIw5COAPE8D67rIggCGu8qrK9rIkkS2qdIFvHw8JDm78/OzugYXNM06ftIdvLXX3+F4zg4PT3F4eEhPM/Dq1ev6CTwgpS/ADLGMAxD+sVnhIxGo4EwDOF5HtbX12emeGdZBtu2cXBwgF6vh7dv3+LFixcYj8dwHAej0YhZXULALCl55K2pMAzhui5s24YkSTg+Pp7RDVmW4e3bt7AsC4PBgH7DENm2WJWOPLjLPiTHcczdgaqq2NzcRK1Wg6ZpNLGVx3A4pMrd8zz69YJRFCEIghsnJsuya4Ufbh0p+aYhEqJf9P3CZJA08X+uM+LwQ+O6pNyK7SsPEsOabzbNI08E8YFuw7ZFcOskBbj4nfXLPPr5mrFV4R8vKQCYDY98KLBV8FQAQEEKkyhIYRAFKQyiIIVBFKQwiIIUBlGQwiAKUhhEQQqDuDT2VWA1eL+kcNxTcNxzcNzTG/g8/0xccw3fLykc9xzA/wD4N7Ls8d//hP+FuOYaXkWn/AvAv3E+c7PA9XGtNSx0CoMorC8GUZDCIApSGERBCoMoSGEQBSkMoiCFQRSkMIiCFAbx/6n4BLUO0DYbAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 144x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pnt_tdl.show_batch(figsize=(2,2), cmap='Greys');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class BBoxLabeler(Transform):\n",
    "    def setups(self, dl): self.vocab = dl.vocab\n",
    "\n",
    "    def decode (self, x, **kwargs):\n",
    "        self.bbox,self.lbls = None,None\n",
    "        return self._call('decodes', x, **kwargs)\n",
    "\n",
    "    def decodes(self, x:TensorMultiCategory):\n",
    "        self.lbls = [self.vocab[a] for a in x]\n",
    "        return x if self.bbox is None else LabeledBBox(self.bbox, self.lbls)\n",
    "\n",
    "    def decodes(self, x:TensorBBox):\n",
    "        self.bbox = x\n",
    "        return self.bbox if self.lbls is None else LabeledBBox(self.bbox, self.lbls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "#LabeledBBox can be sent in a tl with MultiCategorize (depending on the order of the tls) but it is already decoded.\n",
    "@MultiCategorize\n",
    "def decodes(self, x:LabeledBBox): return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@PointScaler\n",
    "def encodes(self, x:TensorBBox):\n",
    "    pnts = self.encodes(cast(x.view(-1,2), TensorPoint))\n",
    "    return cast(pnts.view(-1, 4), TensorBBox)\n",
    "\n",
    "@PointScaler\n",
    "def decodes(self, x:TensorBBox):\n",
    "    pnts = self.decodes(cast(x.view(-1,2), TensorPoint))\n",
    "    return cast(pnts.view(-1, 4), TensorBBox)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _coco_bb(x):  return TensorBBox.create(bbox[0])\n",
    "def _coco_lbl(x): return bbox[1]\n",
    "\n",
    "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_bb], [_coco_lbl, MultiCategorize(add_na=True)]], n_inp=1)\n",
    "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#Check the size was grabbed by PointScaler and added to y\n",
    "tfm = PointScaler()\n",
    "tfm.as_item=False\n",
    "x,y,z = tfm(coco_tds[0])\n",
    "test_eq(tfm.sz, x.size)\n",
    "test_eq(y.get_meta('img_size'), x.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Categorize: {'vocab': None, 'add_na': True}:\n",
       "(object,object) -> encodes\n",
       " (object,object) -> decodes"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Categorize(add_na=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(#3) [Pipeline: PILBase.create,Pipeline: _coco_bb,Pipeline: _coco_lbl -> MultiCategorize: {'vocab': (#2) ['#na#','vase'], 'add_na': True}]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coco_tds.tfms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(PILImage mode=RGB size=128x128,\n",
       " TensorBBox([[-0.9011, -0.4606,  0.1416,  0.6764],\n",
       "         [ 0.2000, -0.2405,  1.0000,  0.9102],\n",
       "         [ 0.4909, -0.9325,  0.9284, -0.5011]]),\n",
       " TensorMultiCategory([1, 1, 1]))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x,y,z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = coco_tdl.one_batch()\n",
    "test_close(y[0], -1+tensor(bbox[0])/64)\n",
    "test_eq(z[0], tensor([1,1,1]))\n",
    "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n",
    "test_close(b, tensor(bbox[0]).float())\n",
    "test_eq(c.bbox, b)\n",
    "test_eq(c.lbl, bbox[1])\n",
    "\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorBBox)\n",
    "test_eq(type(z), TensorMultiCategory)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), TensorBBox)\n",
    "test_eq(type(c), LabeledBBox)\n",
    "test_eq(y.get_meta('img_size'), (128,128))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "coco_tdl.show_batch();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "#test other direction works too\n",
    "coco_tds = Datasets([coco_fn], [PILImage.create, [_coco_lbl, MultiCategorize(add_na=True)], [_coco_bb]])\n",
    "coco_tdl = TfmdDL(coco_tds, bs=1, after_item=[BBoxLabeler(), PointScaler(), ToTensor()])\n",
    "\n",
    "x,y,z = coco_tdl.one_batch()\n",
    "test_close(z[0], -1+tensor(bbox[0])/64)\n",
    "test_eq(y[0], tensor([1,1,1]))\n",
    "a,b,c = coco_tdl.decode_batch((x,y,z))[0]\n",
    "test_eq(b, bbox[1])\n",
    "test_close(c.bbox, tensor(bbox[0]).float())\n",
    "test_eq(c.lbl, b)\n",
    "\n",
    "#Check types\n",
    "test_eq(type(x), TensorImage)\n",
    "test_eq(type(y), TensorMultiCategory)\n",
    "test_eq(type(z), TensorBBox)\n",
    "test_eq(type(a), TensorImage)\n",
    "test_eq(type(b), MultiCategory)\n",
    "test_eq(type(c), LabeledBBox)\n",
    "test_eq(z.get_meta('img_size'), (128,128))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_torch_core.ipynb.\n",
      "Converted 01_layers.ipynb.\n",
      "Converted 02_data.load.ipynb.\n",
      "Converted 03_data.core.ipynb.\n",
      "Converted 04_data.external.ipynb.\n",
      "Converted 05_data.transforms.ipynb.\n",
      "Converted 06_data.block.ipynb.\n",
      "Converted 07_vision.core.ipynb.\n",
      "Converted 08_vision.data.ipynb.\n",
      "Converted 09_vision.augment.ipynb.\n",
      "Converted 09b_vision.utils.ipynb.\n",
      "Converted 09c_vision.widgets.ipynb.\n",
      "Converted 10_tutorial.pets.ipynb.\n",
      "Converted 11_vision.models.xresnet.ipynb.\n",
      "Converted 12_optimizer.ipynb.\n",
      "Converted 13_callback.core.ipynb.\n",
      "Converted 13a_learner.ipynb.\n",
      "Converted 13b_metrics.ipynb.\n",
      "Converted 14_callback.schedule.ipynb.\n",
      "Converted 14a_callback.data.ipynb.\n",
      "Converted 15_callback.hook.ipynb.\n",
      "Converted 15a_vision.models.unet.ipynb.\n",
      "Converted 16_callback.progress.ipynb.\n",
      "Converted 17_callback.tracker.ipynb.\n",
      "Converted 18_callback.fp16.ipynb.\n",
      "Converted 18a_callback.training.ipynb.\n",
      "Converted 19_callback.mixup.ipynb.\n",
      "Converted 20_interpret.ipynb.\n",
      "Converted 20a_distributed.ipynb.\n",
      "Converted 21_vision.learner.ipynb.\n",
      "Converted 22_tutorial.imagenette.ipynb.\n",
      "Converted 23_tutorial.vision.ipynb.\n",
      "Converted 24_tutorial.siamese.ipynb.\n",
      "Converted 24_vision.gan.ipynb.\n",
      "Converted 30_text.core.ipynb.\n",
      "Converted 31_text.data.ipynb.\n",
      "Converted 32_text.models.awdlstm.ipynb.\n",
      "Converted 33_text.models.core.ipynb.\n",
      "Converted 34_callback.rnn.ipynb.\n",
      "Converted 35_tutorial.wikitext.ipynb.\n",
      "Converted 36_text.models.qrnn.ipynb.\n",
      "Converted 37_text.learner.ipynb.\n",
      "Converted 38_tutorial.text.ipynb.\n",
      "Converted 39_tutorial.transformers.ipynb.\n",
      "Converted 40_tabular.core.ipynb.\n",
      "Converted 41_tabular.data.ipynb.\n",
      "Converted 42_tabular.model.ipynb.\n",
      "Converted 43_tabular.learner.ipynb.\n",
      "Converted 44_tutorial.tabular.ipynb.\n",
      "Converted 45_collab.ipynb.\n",
      "Converted 46_tutorial.collab.ipynb.\n",
      "Converted 50_tutorial.datablock.ipynb.\n",
      "Converted 60_medical.imaging.ipynb.\n",
      "Converted 61_tutorial.medical_imaging.ipynb.\n",
      "Converted 65_medical.text.ipynb.\n",
      "Converted 70_callback.wandb.ipynb.\n",
      "Converted 71_callback.tensorboard.ipynb.\n",
      "Converted 72_callback.neptune.ipynb.\n",
      "Converted 73_callback.captum.ipynb.\n",
      "Converted 74_callback.cutmix.ipynb.\n",
      "Converted 97_test_utils.ipynb.\n",
      "Converted 99_pytorch_doc.ipynb.\n",
      "Converted index.ipynb.\n",
      "Converted tutorial.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from nbdev.export import notebook2script\n",
    "notebook2script()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "split_at_heading": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
